package innerclass;

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}

class Outer04{ // 外部类
    private int n1 = 10; // 属性

    public void method() {//方法
        //基于接口的匿名内部类
        //1.需求：想使用IA接口，并创建对象
        //2.传统方式，是写一个类，实现该接口，并创建对象
//        IAA tiger = new Tiger();
//        tiger.cry();
        //3.需求：Tiger类只用一次，后面再不使用
        //4.可以使用匿名内部类来简化开发
        //5.tiger编译类型？IAA
        //6.tiger运行类型？就是匿名内部类
        /*
        底层会分配类名 Outer$1
        class Outer04$1 implements IAA{
                @Override
                public void cry() {
                    System.out.println("老虎叫唤...");
                }
         }
         */
        //7.jdk底层在创建匿名内部类Outer04$1，立即马上就创建了Outer04$1实例
        //并且把地址返回给tiger
        IAA tiger = new IAA(){
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger的运行类型=" + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();

        //基于类的匿名内部类
        //1.father的编译类型 Father
        //2.father的运行类型 Outer04$2
        //3.底层会创建匿名内部类
        /*
        class Outer04$2 extends Father{
        }
         */
        Father father = new Father("jack"){
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型=" + father.getClass());
        father.test();
    }
}

interface IAA {//接口
    public void cry();
}

//class Tiger implements IAA {
//    @Override
//    public void cry() {
//        System.out.println("老虎叫唤...");
//    }
//}
//
//class Dog implements IAA {
//    @Override
//    public void cry() {
//        System.out.println("小狗汪汪叫...");
//    }
//}

class Father{//类
    public Father(String name) { // 构造器
    }
    public void test() {//方法
    }
}